package com.mvd.app.ac2019;

import android.Manifest;
import android.content.Context;
import android.content.Intent;
import android.graphics.Color;
import android.graphics.drawable.BitmapDrawable;
import android.os.Bundle;
import android.os.Environment;
import android.support.annotation.NonNull;
import android.text.TextUtils;
import android.util.Base64;
import android.view.View;
import android.widget.AdapterView;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ImageView;
import android.widget.LinearLayout;
import android.widget.ListView;
import android.widget.PopupWindow;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.kongzue.dialog.interfaces.OnDialogButtonClickListener;
import com.kongzue.dialog.util.BaseDialog;
import com.kongzue.dialog.v3.MessageDialog;
import com.kongzue.dialog.v3.WaitDialog;
import com.lzy.okgo.OkGo;
import com.lzy.okgo.callback.StringCallback;
import com.lzy.okgo.model.Response;
import com.lzy.okgo.request.base.Request;
import com.mvd.app.R;
import com.mvd.app.activity.BaseActivity;
import com.mvd.app.activity.PermissionUtils;
import com.mvd.app.activity.SettingActivity;
import com.mvd.app.adapter.MyAccountModeListAdapter;
import com.mvd.app.adapter.UserAccountListAdapter;
import com.mvd.app.application.BaseApplication;
import com.mvd.app.application.SharedDatabaseHelper;
import com.mvd.app.commons.Base64Util;
import com.mvd.app.commons.CommonUtils;
import com.mvd.app.commons.Constants;
import com.mvd.app.commons.DeleteFileUtils;
import com.mvd.app.commons.JsonUtil;
import com.mvd.app.commons.PDALogUtils;
import com.mvd.app.commons.SharedPreferencesUtils;
import com.mvd.app.commons.Utils;
import com.mvd.app.commons.UtilsLog;
import com.mvd.app.model.CheckItemModel;
import com.mvd.app.model.UserAccountModel;
import com.mvd.app.widget.EditTextViewWorksSizeCheckUtil;
import com.mvd.app.widget.IEditTextChangeListener;
import com.werb.permissionschecker.PermissionChecker;
import com.zhihu.matisse.Matisse;
import com.zhihu.matisse.MimeType;
import com.zhihu.matisse.engine.impl.PicassoEngine;

import org.json.JSONObject;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import butterknife.BindView;
import butterknife.ButterKnife;
import butterknife.OnClick;
import mabeijianxi.camera.VCamera;
import mabeijianxi.camera.util.DeviceUtils;

import static com.mvd.app.application.BaseApplication.checkItemModelList;

/**
 * @Description: 新版的登录
 * 2019
 */
public class LoginActivity extends BaseActivity {
    int TYPE_POP = 0;//popuwindow 0：检测模式   1：账号
    @BindView(R.id.imageView)
    ImageView imageView;
    @BindView(R.id.textView)
    TextView textView;
    @BindView(R.id.ac_login_account)
    TextView acLoginAccount;
    @BindView(R.id.ac_login_pwd)
    EditText acLoginPwd;
    @BindView(R.id.ac_login_check_mode)
    TextView acLoginCheckMode;
    @BindView(R.id.ac_login_btn_set)
    Button acLoginBtnSet;
    @BindView(R.id.ac_login_view_m)
    TextView acLoginViewM;
    @BindView(R.id.ac_login_btn_login)
    Button acLoginBtnLogin;

    BaseApplication baseApplication;
    private UserAccountListAdapter userAccountListAdapter;
    private List<UserAccountModel> resultList = null;

    private int Currentindex = 0;//用户名当前的position
    private boolean Is_skip = false;//登录按钮点击后是否可以跳转
    private LoginActivity instances = null;
    public static String[] permissionArray = new String[]{
            android.Manifest.permission.READ_EXTERNAL_STORAGE,
            android.Manifest.permission.WRITE_EXTERNAL_STORAGE,
            android.Manifest.permission.WRITE_SETTINGS,
            android.Manifest.permission.ACCESS_FINE_LOCATION,
            android.Manifest.permission.CAMERA,
            android.Manifest.permission.READ_CALENDAR,
    };
    static final String[] PERMISSIONS = new String[]{
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.CAMERA,
            Manifest.permission.READ_PHONE_STATE,
            Manifest.permission.READ_EXTERNAL_STORAGE
    };
    private PermissionChecker permissionChecker;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        ButterKnife.bind(this);
        instances = LoginActivity.this;
        baseApplication = BaseApplication.getSelf();
        String msg = "=======PDA-LOG=====" + "\n" + "移动检测系统版本号::::" +
                CommonUtils.getVersionName(instances) + "\n" +
                instances.getResources().getString(R.string.setting_content);
        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, msg.getBytes());

        String logStrf = "\n" + "onCreate-----登陆-------" + "\n";
        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStrf.getBytes());
        PermissionUtils.checkPermissionArray(this, permissionArray, 2);
        UtilsLog.e("MoRenLine2==" + SharedPreferencesUtils.getMoRenLine2(this));
        permissionChecker = new PermissionChecker(this); // initialize，must need

        if (permissionChecker.isLackPermissions(PERMISSIONS)) {
            permissionChecker.requestPermissions();
            UtilsLog.e("请求录像权限失败===");
        } else {
            // startVideo();
            UtilsLog.e("请求录像权限成功===");
        }

//        VideoUploadModel videoUploadModel=null;
//        for (int i = 0; i <3 ; i++) {
//            videoUploadModel=new VideoUploadModel();
//            videoUploadModel.setCarNO("111"+i);
//            videoUploadModel.setVIN("12jkj"+i);
//            videoUploadModel.setStatement("0");
//            videoUploadModel.save();
//        }
        SharedDatabaseHelper s = new SharedDatabaseHelper(this);
        //删除拍照编辑图片的文件夹
        UtilsLog.e("图片的文件夹===" + Environment.getExternalStorageDirectory() + "/Pictures");
//        com.mvd.app.commons.FileUtils.deleteDir(Environment.getExternalStorageDirectory() + "/SavaboonPictures");
//
//        com.mvd.app.commons.FileUtils.deleteDirectory(Environment.getExternalStorageDirectory() + "/SavaboonPictures");

        textView.setText("移动检测系统" + CommonUtils.getVersionName(instances));
        UtilsLog.e("当前选择的版本号：" + CommonUtils.getVersionName(instances));
        pop_account();
        pop_account_userlist();
        // 设置默认更新接口地址与渠道
//        UpdateManager.setUrl("http://www.baidu.com", "yyb");
// 进入应用时查询更新
//        UpdateManager.check(this);

        //1.创建工具类对象 把要改变颜色的tv先传过去
        EditTextViewWorksSizeCheckUtil.textChangeListener textChangeListener = new
                EditTextViewWorksSizeCheckUtil.textChangeListener(acLoginBtnLogin);

        //2.把所有要监听的edittext都添加进去
        textChangeListener.addAllEditText(acLoginPwd);

        //3.接口回调 在这里拿到boolean变量 根据isHasContent的值决定 tv 应该设置什么颜色
        EditTextViewWorksSizeCheckUtil.setChangeListener(new IEditTextChangeListener() {
            @Override
            public void textChange(boolean isHasContent) {
                if (isHasContent) {
                    acLoginBtnLogin.setTextColor(Color.WHITE);
                    acLoginBtnLogin.setEnabled(true);
                } else {
                    acLoginBtnLogin.setTextColor(Color.GRAY);
                    acLoginBtnLogin.setEnabled(false);
                }
            }
        });
        //记录上次选择的检测模式
        // cLoginCheckMode.setText(strModes.get(BaseApplication.JIANCE_MODE));
        SharedPreferencesUtils.setPhotoAlbumStatement(instances, false);

        //记录上次选择的用户名
//        acLoginAccount.setText(SharedPreferencesUtils.getUserGender(instances));
//        UtilsLog.e("记录上次选择的用户名=="+SharedPreferencesUtils.getUserGender(instances));
//        UtilsLog.e("记录上次选择的ID=="+SharedPreferencesUtils.getUID(instances));
//        initUserList();
        String logStr = "\n" + "当前系统版本====" + this.getResources().getString(R.string.setting_content) +
                "\n";
        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
        String str0 = "", str1 = "";
        str0 = CommonUtils.getIMEI(this, 0);
        str1 = CommonUtils.getIMEI(this, 1);
        UtilsLog.e("手机IMEI---1---" + str0);
        UtilsLog.e("手机IMEI---2---" + str1);
//        getVideo();
//        initSmallVideo(this);

        //定时删除日志
        DeleteFileUtils.removeFileByTime(Environment.getExternalStorageDirectory() + "/PDALogs/");

//        setImg();
        aaaaaa();
    }

    void aaaaaa() {
        String validJson = "{\"key\": \"value\"}";
        String invalidJson = "{key: value}";
        String result = "互联网预约信息下载失败：未实现该方法或操作。";
        UtilsLog.e(Utils.isJson(validJson) + "111111111");
        UtilsLog.e(Utils.isJson(invalidJson) + "22222222");
        UtilsLog.e(Utils.isJson(result) + "3333333333");
    }

    public static void initSmallVideo(Context context) {
        // 设置拍摄视频缓存路径
//        filePath =  Environment.getExternalStorageDirectory() + "/myvideo/";
        File dcim = Environment
                .getExternalStoragePublicDirectory(Environment.DIRECTORY_DCIM);
        if (DeviceUtils.isZte()) {
            if (dcim.exists()) {
                VCamera.setVideoCachePath(dcim + "/AA/");
            } else {
                VCamera.setVideoCachePath(dcim.getPath().replace("/sdcard/",
                        "/sdcard-ext/")
                        + "/AA/");
            }
        } else {
            VCamera.setVideoCachePath(dcim + "/AA/");
        }
        VCamera.setDebugMode(true);
        VCamera.initialize(context);
    }

    void getVideo() {
        Matisse.from(LoginActivity.this)
                .choose(MimeType.of(MimeType.MP4))
                .theme(R.style.Matisse_Dracula)
                .countable(false)
                .maxSelectable(1)
                .imageEngine(new PicassoEngine())
                .forResult(9985);
    }

    List<String> paths = new ArrayList<>();

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode == 9985 && resultCode == RESULT_OK) {
            paths = Matisse.obtainPathResult(data);
            if (paths != null) {
                UtilsLog.e("-------------" + paths.toString());
                UtilsLog.e("-----getPath--------" + paths.get(0));
            } else {
                UtilsLog.e("----9985---------");
            }
        }
    }

    void initUserList() {
//        WaitDialog.show(instances, "加载中...");
//        Handler handler = new Handler();
//        handler.postDelayed(new Runnable() {
//            @Override
//            public void run() {
//                WaitDialog.dismiss();
//            }
//        }, 1500);//后执行Runnable中的run方法

        PDALogUtils.checkPhotoSetting();
        if (!TextUtils.isEmpty(SharedPreferencesUtils.getIP(instances)) &&
                !TextUtils.isEmpty
                        (SharedPreferencesUtils.getFileIP(instances))) {
            if (CommonUtils.isNetworkConnected(instances)) {
                getDataUsersList();
                //获取所有人工检验项目接口
                getGET_ALL_ITEMList();
            } else {
                WaitDialog.dismiss();
                Toast.makeText(instances, getResources().getString(R.string.network_error), Toast
                        .LENGTH_LONG).show();
            }
        } else {
            WaitDialog.dismiss();
            Toast.makeText(instances, "请设置IP与端口号", Toast.LENGTH_LONG).show();
        }
    }

    private View view2;
    private RelativeLayout parent22;
    private PopupWindow pop2 = null;
    private ListView listview_modes;
    private List<String> strModes = new ArrayList<String>();
    MyAccountModeListAdapter MyAccountModeListAdapter;

    private void pop_account() {
        for (int i = 0; i < Constants.MY_ACCOUNT_MODEL_LIST.length; i++) {
            strModes.add(i, Constants.MY_ACCOUNT_MODEL_LIST[i]);
        }
        pop2 = new PopupWindow(this);
        view2 = getLayoutInflater().inflate(R.layout.item_popupwindows_bottom,
                null);
        pop2.setWidth(LinearLayout.LayoutParams.MATCH_PARENT);
        pop2.setHeight(LinearLayout.LayoutParams.WRAP_CONTENT);
        pop2.setBackgroundDrawable(new BitmapDrawable());
        pop2.setFocusable(true);
        pop2.setOutsideTouchable(true);
        pop2.setContentView(view2);

        parent22 = (RelativeLayout) view2.findViewById(R.id.parent2);
        listview_modes = (ListView) view2.findViewById(R.id.themeid_listview);
//        //popuwindow 0：检测模式   1：账号
//        if (TYPE_POP == 0) {
//        } else {
//        }
        parent22.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                pop2.dismiss();
            }
        });
    }

    private View view2_userlist;
    private RelativeLayout parent22_userlist;
    private PopupWindow pop2_userlist = null;
    private ListView listview_modes_userlist;

    private void pop_account_userlist() {
        pop2_userlist = new PopupWindow(this);
        view2_userlist = getLayoutInflater().inflate(R.layout.item_popupwindows_bottom,
                null);
        pop2_userlist.setWidth(LinearLayout.LayoutParams.MATCH_PARENT);
        pop2_userlist.setHeight(LinearLayout.LayoutParams.WRAP_CONTENT);
        pop2_userlist.setBackgroundDrawable(new BitmapDrawable());
        pop2_userlist.setFocusable(true);
        pop2_userlist.setOutsideTouchable(true);
        pop2_userlist.setContentView(view2_userlist);

        parent22_userlist = (RelativeLayout) view2_userlist.findViewById(R.id.parent2);
        listview_modes_userlist = (ListView) view2_userlist.findViewById(R.id.themeid_listview);
        parent22_userlist.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                pop2_userlist.dismiss();
            }
        });
    }

    @OnClick({R.id.imageView, R.id.ac_login_account, R.id.ac_login_check_mode, R.id.ac_login_btn_set,
            R.id.ac_login_btn_login})
    public void onViewClicked(View view) {
        {
            switch (view.getId()) {
                //账号
                case R.id.ac_login_account:
                    TYPE_POP = 1;
                    pop2_userlist.showAsDropDown(acLoginAccount);
                    if (resultList != null && resultList.size() > 0) {
                        listview_modes_userlist.setOnItemClickListener(new AdapterView.OnItemClickListener() {

                            @Override
                            public void onItemClick(AdapterView<?> arg0, View arg1,
                                                    int position, long arg3) {
                                UtilsLog.e("当前选择的用户名==" + resultList.get(position)
                                        .getUserName());
                                acLoginAccount.setText(resultList.get(position)
                                        .getUserName());
                                Currentindex = position;
                                pop2_userlist.dismiss();
                                SharedPreferencesUtils.setUserGender(LoginActivity.this, acLoginAccount.getText().toString().trim());
                                SharedPreferencesUtils.setUID(LoginActivity.this, String.valueOf(resultList.get(position).getUserID()));
                            }
                        });
                    } else {
//                        Toast.makeText(instances, getResources().getString(R.string.network_error), Toast
// .LENGTH_LONG).show();
                        return;
                    }
                    break;
                //检测模式
                case R.id.ac_login_check_mode:
//                pop2.showAtLocation(acLoginCheckMode, Gravity.CENTER_HORIZONTAL, 0, 30);
                    TYPE_POP = 0;
                    if (strModes.size() > 0) {
                        MyAccountModeListAdapter = new MyAccountModeListAdapter(LoginActivity.this, strModes);
                        listview_modes.setAdapter(MyAccountModeListAdapter);
                        listview_modes.setOnItemClickListener(new AdapterView.OnItemClickListener() {

                            @Override
                            public void onItemClick(AdapterView<?> arg0, View arg1,
                                                    int position, long arg3) {
                                BaseApplication.JIANCE_MODE = position;
                                UtilsLog.e("当前选择的检测模式：" + position);
                                acLoginCheckMode.setText(strModes.get(position));
                                pop2.dismiss();
                            }
                        });
                    }
                    pop2.showAsDropDown(acLoginCheckMode);
                    break;
                //设置
                case R.id.ac_login_btn_set:
//                    instances.finish();
                    String login_username = acLoginAccount.getText().toString().trim();
                    Intent intent = new Intent(LoginActivity.this, SettingActivity.class);
                    intent.putExtra("login_username", login_username);
                    startActivity(intent);
//                this.overridePendingTransition(R.anim.push_left_in,R.anim.push_left_out);
                    break;
                //登录
                case R.id.ac_login_btn_login:
                    String UserID = acLoginAccount.getText().toString().trim();
                    String pwd = acLoginPwd.getText().toString().trim();
                    UtilsLog.e("UserID==" + UserID);
                    UtilsLog.e("pwd==" + pwd);
                    UtilsLog.e("Currentindex==" + Currentindex);
                    UtilsLog.e("UserRight==" + resultList.get(Currentindex)
                            .getUserRight());
                    if (!TextUtils.isEmpty(UserID) && !TextUtils.isEmpty(pwd)) {
                        if (!TextUtils.isEmpty(resultList.get(Currentindex)
                                .getUserRight())) {
                            //判定用户的权限
                            switch (BaseApplication.JIANCE_MODE) {
                                case 0:
                                    //外检
                                    if (resultList.get(Currentindex).getUserRight
                                            ().contains("0")
                                            || resultList.get(Currentindex)
                                            .getUserRight().contains("3")) {
                                        Is_skip = true;
                                    } else {
                                        Is_skip = false;
                                        Toast.makeText(this, getResources().getString(R.string
                                                .quanxian_inconformity), Toast.LENGTH_LONG).show();
                                    }
                                    if (resultList.get(Currentindex).getUserRight
                                            ().equals("")) {
                                        Is_skip = true;
                                    }
                                    break;
                                case 1:
                                    //路试
                                    if (resultList.get(Currentindex).getUserRight
                                            ().contains("0")
                                            || resultList.get(Currentindex)
                                            .getUserRight().contains("6")) {
                                        Is_skip = true;
                                    } else {
                                        Is_skip = false;
                                        Toast.makeText(this, getResources().getString(R.string
                                                .quanxian_inconformity), Toast.LENGTH_LONG).show();
                                    }
                                    if (resultList.get(Currentindex).getUserRight
                                            ().equals("")) {
                                        Is_skip = true;
                                    }
                                    break;
                                case 2:
                                    //底盘动态
                                    if (resultList.get(Currentindex).getUserRight
                                            ().contains("0")
                                            || resultList.get(Currentindex)
                                            .getUserRight().contains("4")) {
                                        Is_skip = true;
                                    } else {
                                        Is_skip = false;
                                        Toast.makeText(this, getResources().getString(R.string
                                                .quanxian_inconformity), Toast.LENGTH_LONG).show();
                                    }
                                    if (resultList.get(Currentindex).getUserRight
                                            ().equals("")) {
                                        Is_skip = true;
                                    }
                                    break;
                                case 3:
                                    //调度
//                                    if (BaseApplication.userAccountModelList.get(Currentindex).getUserRight
//                                            ().contains("2")
//                                            ) {
//                                        Is_skip = true;
//                                    } else {
//                                        Is_skip = false;
//                                        Toast.makeText(this, getResources().getString(R.string
//                                                .quanxian_inconformity), Toast.LENGTH_LONG).show();
//                                    }
//                                    if (BaseApplication.userAccountModelList.get(Currentindex).getUserRight
//                                            ().equals("")) {
                                    Is_skip = true;
//                                    }
                                    break;
                                case 6:
                                    //登陆
//                                    if (BaseApplication.userAccountModelList.get(Currentindex).getUserRight
//                                            ().contains("0")
//                                            || BaseApplication.userAccountModelList.get(Currentindex)
//                                            .getUserRight().contains("4")) {
//                                        Is_skip = true;
//                                    } else {
//                                        Is_skip = false;
//                                        Toast.makeText(this, getResources().getString(R.string
//                                                .quanxian_inconformity), Toast.LENGTH_LONG).show();
//                                    }
//                                    if (BaseApplication.userAccountModelList.get(Currentindex).getUserRight
//                                            ().equals("")) {
//                                        Is_skip = true;
//                                    }
                                    Is_skip = true;
                                    break;
                            }
                        }
                        if (Is_skip) {
                            //调用登录接口
//                            getDataToLogin(BaseApplication.userAccountModelList.get(Currentindex).getUserID(), pwd);

                            if (TYPE_POP == 1) {
                                getDataToLogin(resultList.get(Currentindex).getUserID(), pwd);
                            } else {
                                getDataToLogin(SharedPreferencesUtils.getUID(instances), pwd);
                            }
                        }
                    } else {
                        Toast.makeText(instances, getResources().getString(R.string.username_pwd_null),
                                Toast.LENGTH_LONG).show();
                    }
                    break;
                case R.id.imageView:
//                    Intent i=new Intent(this,AdminActivity.class);
//                    startActivity(i);

                    String UserID2 = acLoginAccount.getText().toString().trim();
                    if (!TextUtils.isEmpty(UserID2)) {
                        logOut(UserID2);
                    }
                    // 录制
//                    MediaRecorderConfig config = new MediaRecorderConfig.Buidler()
//                            .doH264Compress(new AutoVBRMode()
////                        .setVelocity(BaseMediaBitrateConfig.Velocity.ULTRAFAST)
//                            )
//                            .setMediaBitrateConfig(new AutoVBRMode()
////                        .setVelocity(BaseMediaBitrateConfig.Velocity.ULTRAFAST)
//                            )
//                            .smallVideoWidth(480)
//                            .smallVideoHeight(360)
//                            .recordTimeMax(6 * 1000)
//                            .maxFrameRate(20)
//                            .captureThumbnailsTime(1)
//                            .recordTimeMin((int) (1.5 * 1000))
//                            .build();
//                    MediaRecorderActivity.goSmallVideoRecorder(this, MediaRecorderActivity.class.getName(), config);
//                    Intent intent3 = new Intent(LoginActivity.this, DaiJianCarsActivity.class);
//                    Intent intent3 = new Intent(LoginActivity.this, OnlineActivity.class);
//                    startActivity(intent3);
                    break;
            }
        }
    }

    @Override
    protected void onResume() {
        super.onResume();
//        WaitDialog.show(instances, "加载中...");
////        Handler handler = new Handler();
////        handler.postDelayed(new Runnable() {
////            @Override
////            public void run() {
////                WaitDialog.dismiss();
////            }
////        }, 1500);//后执行Runnable中的run方法
//        PDALogUtils.checkPhotoSetting();
//        if (!TextUtils.isEmpty(SharedPreferencesUtils.getIP(instances)) &&
//                !TextUtils.isEmpty
//                (SharedPreferencesUtils.getFileIP(instances))) {
//            if (CommonUtils.isNetworkConnected(instances)) {
//                getDataUsersList();
//                //获取所有人工检验项目接口
//                getGET_ALL_ITEMList();
//            } else {
//                Toast.makeText(instances, getResources().getString(R.string.network_error), Toast
//                        .LENGTH_LONG).show();
//            }
//        } else {
//            Toast.makeText(instances, "请设置IP与端口号", Toast.LENGTH_LONG).show();
//        }
        initUserList();
    }

    //获取用户列表
    private void getDataUsersList() {
        UtilsLog.e("6666666666666===");
        UtilsLog.e("getDataUsersList---url==" + SharedPreferencesUtils.getIP(instances) + GETALLUSERS);
        String logStr = "\n" + "获取用户列表--getDataUsersList----" + "\n" + "URL::" +
                SharedPreferencesUtils.getIP(instances) + GETALLUSERS + "\n";
        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
        OkGo.<String>get(SharedPreferencesUtils.getIP(instances) + GETALLUSERS).tag(instances)
                .execute(new StringCallback() {
                    @Override
                    public void onStart(Request<String, ? extends Request> request) {
                        super.onStart(request);
                        WaitDialog.show(instances, "加载中...");
//                        CommonUtils.showLoadingDialog(instances, "加载中...");
                    }

                    @Override
                    public void onSuccess(Response<String> response) {
//                        CommonUtils.hideLoadingDialog(instances);
                        String result = response.body();
//                        UtilsLog.e("getDataUsersList-result==" + result);
                        String newResult = result.substring(1, result.length() - 1).replaceAll("\\\\", "");
                        UtilsLog.e("getDataUsersList-newResult==" + newResult);
//                        String logStr = "\n" + "获取用户列表--getDataUsersList----onSuccess" + "\n" + "URL::" +
//                                SharedPreferencesUtils.getIP(instances) +
//                                GETALLUSERS + "\n" + "result::" + result + "\n";
//                        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
                        if (!TextUtils.isEmpty(newResult) && !"[[]]".equals(newResult) && !"[{}]".equals
                                (newResult) && !"[]".equals(result)) {

                            try {
                                BaseApplication.userAccountModelList = JsonUtil.stringToArray(newResult,
                                        UserAccountModel[].class);
                                //0  3  4  6
                                if (BaseApplication.userAccountModelList != null && BaseApplication.userAccountModelList.size() > 0) {
                                    resultList = filterRoleRight(BaseApplication.userAccountModelList);
                                    userAccountListAdapter = new UserAccountListAdapter(LoginActivity.this,
                                            resultList);
                                    listview_modes_userlist.setAdapter(userAccountListAdapter);
                                }
                            } catch (Exception e) {
                                UtilsLog.e("getDataUsersList-Exception==" + e.getMessage());
                            }
                        } else {
//                            Toast.makeText(instances, getResources().getString(R.string.network_error),
// Toast.LENGTH_LONG).show();
                            UtilsLog.e("getDataUsersList-result==" + "没有数据");
                        }
                        WaitDialog.dismiss();
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                        WaitDialog.dismiss();
//                        CommonUtils.hideLoadingDialog(instances);
                        String logStr = "\n" + "获取用户列表--getDataUsersList----onError" + "\n" + "URL::" +
                                SharedPreferencesUtils.getIP(instances) +
                                GETALLUSERS + "\n" + "result::" + response.body() + "\n";
                        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
                        UtilsLog.e("getDataUsersList-onError==" + response.body());
                        MessageDialog.show(instances, "提示", "读取人员列表失败，请重试", "确定", "取消")
                                .setOkButton(new OnDialogButtonClickListener() {
                                    @Override
                                    public boolean onClick(BaseDialog baseDialog, View v) {
//                                Toast.makeText(instances, "1234555", Toast.LENGTH_LONG).show();
                                        getDataUsersList();
                                        return false;
                                    }
                                }).setCancelButton(new OnDialogButtonClickListener() {
                            @Override
                            public boolean onClick(BaseDialog baseDialog, View v) {

                                return false;
                            }
                        });
//                        Toast.makeText(instances, "读取人员列表失败，请退出重试", Toast
//                                .LENGTH_LONG).show();
                    }
                });
    }

    //登录
    private void getDataToLogin(final String UserID, String LoginPass) {
        UtilsLog.e("getDataToLogin---url==" + SharedPreferencesUtils.getIP(instances) + USERLOGIN);
//        {"UserID":"2", "LoginPass":"2"}
        Map<String, String> params = new HashMap<>();
        params.put("ID", UserID);
        params.put("Psw", LoginPass);
        JSONObject jsonObject = new JSONObject(params);
        UtilsLog.e("getDataToLogin---json==" + jsonObject.toString());
        String logStr = "\n" + "登录--getDataToLogin----json" + "\n" + "URL::" +
                SharedPreferencesUtils.getIP(instances) +
                USERLOGIN + "\n" + "json::" + jsonObject.toString() + "\n";
        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
        OkGo.<String>post(SharedPreferencesUtils.getIP(instances) + USERLOGIN).tag(instances)
                .upJson(jsonObject)
                .execute(new StringCallback() {
                    @Override
                    public void onStart(Request<String, ? extends Request> request) {
                        super.onStart(request);
                    }

                    @Override
                    public void onSuccess(Response<String> response) {
                        String result = response.body();
//                        UtilsLog.e("getDataToLogin-result==" + result);
                        String newResult = result.substring(1, result.length() - 1).replaceAll("\\\\", "");
                        UtilsLog.e("getDataToLogin-newResult==" + newResult);
                        String logStr = "\n" + "登录--getDataToLogin----onSuccess" + "\n" + "URL::" +
                                SharedPreferencesUtils.getIP(instances) +
                                USERLOGIN + "\n" + "result::" + result + "\n";
                        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
                        if (!TextUtils.isEmpty(newResult) && !"[[]]".equals(newResult) && !"[{}]".equals
                                (newResult) && !"[]".equals(newResult)) {
                            BaseApplication.accountModelList = JsonUtil.stringToArray(newResult,
                                    UserAccountModel[].class);
                            if (BaseApplication.accountModelList.size() > 0) {
                                UtilsLog.e(" BaseApplication.JIANCE_MODE-login==" + BaseApplication.JIANCE_MODE);

                                Intent intent2 = null;
                                //检测模式 0:外检  1：路试 2：底盘动态 3:调度
                                String login_name = acLoginAccount.getText().toString().trim();

//                                switch (BaseApplication.JIANCE_MODE) {
//                                    case 0:
//                                        intent2 = new Intent(LoginActivity.this, DaiJianCarsActivity.class);
//                                        break;
//                                    case 1:
//                                        intent2 = new Intent(LoginActivity.this, DaiJianCarsActivity.class);
//                                        break;
//                                    case 2:
//                                        intent2 = new Intent(LoginActivity.this, DaiJianCarsActivity.class);
//                                        break;
//                                    case 3:
//                                        intent2 = new Intent(LoginActivity.this, DiaoDuActivity.class);
////                                        intent2 = new Intent(LoginActivity.this, NewCarsListActivity.class);
//                                        break;
//                                    case 6:
//                                        intent2 = new Intent(LoginActivity.this, DengLuActivity.class);
//                                        break;
//                                }
//                                if (BaseApplication.JIANCE_MODE == 0) {
//                                    intent2 = new Intent(LoginActivity.this, DaiJianCarsActivity.class);
//                                } else {
//                                    intent2 = new Intent(LoginActivity.this, NewCarsListActivity.class);
//                                }
                                if (BaseApplication.accountModelList.get(0).getStatus() == 1) {
                                    Toast.makeText(instances, "当前账号已登录", Toast.LENGTH_LONG).show();
                                } else {
                                    intent2 = new Intent(LoginActivity.this, FirstActivity.class);
                                    intent2.putExtra("check_mode", BaseApplication.JIANCE_MODE);
                                    intent2.putExtra("login_UserID", login_name);
                                    UtilsLog.e("LoginActivity-----UserAccountModel_model===" + resultList.get(Currentindex).toString());
                                    intent2.putExtra("UserAccountModel_model", resultList.get(Currentindex));
                                    intent2.putExtra("login_username", BaseApplication.accountModelList.get(0).getUserName());
                                    UtilsLog.e("getDataToLogin-login_IDNumber==" + BaseApplication.accountModelList.get(0).getIDNumber());
                                    if (!TextUtils.isEmpty(BaseApplication.accountModelList.get(0).getIDNumber())) {
                                        intent2.putExtra("login_IDNumber", BaseApplication.accountModelList.get(0).getIDNumber());
                                    } else {
                                        intent2.putExtra("login_IDNumber", "");
                                    }
                                    startActivity(intent2);
                                    finish();
                                }
                            }
                        } else {
                            Toast.makeText(instances, "登陆失败，请重试", Toast.LENGTH_LONG).show();
                            UtilsLog.e("getDataToLogin-result==" + "没有数据");
                        }
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                        UtilsLog.e("getDataUsersList-onError==" + response.body());
                        String logStr = "\n" + "登录--getDataToLogin----onError" + "\n" + "URL::" +
                                SharedPreferencesUtils.getIP(instances) +
                                USERLOGIN + "\n" + "result::" + response.body() + "\n";
                        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
                        Toast.makeText(instances, LoginActivity.this.getResources().getString(R.string
                                .try_again), Toast.LENGTH_LONG).show();
                    }
                });
    }

    //获取所有人工检验项目接口
    private void getGET_ALL_ITEMList() {
        String url = "";
//        if (SharedPreferencesUtils.get38900(instances)) {
        url = GET_ALL_ITEM38900;
//        } else {
//            url = GET_ALL_ITEM;
//        }
        String logStr = "\n" + "获取所有人工检验项目接口----" + "\n" + "URL::" +
                SharedPreferencesUtils.getIP(instances) +
                url + "\n";
        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
        UtilsLog.e("getGET_ALL_ITEMList---url==" + SharedPreferencesUtils.getIP(instances) + url);
        OkGo.<String>get(SharedPreferencesUtils.getIP(instances) + url).tag(instances)
                .execute(new StringCallback() {
                    @Override
                    public void onStart(Request<String, ? extends Request> request) {
                        super.onStart(request);
//                        CommonUtils.showLoadingDialog(instances, "加载中...");
                    }

                    @Override
                    public void onSuccess(Response<String> response) {
//                        CommonUtils.hideLoadingDialog(instances);
                        String result = response.body();
//                        UtilsLog.e("getGET_ALL_ITEMList-result==" + result);
                        String newResult = result.substring(1, result.length() - 1).replaceAll("\\\\", "");
//                        UtilsLog.e("getGET_ALL_ITEMList-newResult==" + newResult);
//                        String logStr = "\n" + "获取所有人工检验项目接口----onSuccess" + "\n" + "result::" + response.body() + "\n";
//                        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
                        if (!TextUtils.isEmpty(newResult) && !"[[]]".equals(newResult) && !"[{}]".equals
                                (newResult) && !"[]".equals(result)) {
                            checkItemModelList = new ArrayList<CheckItemModel>();
                            checkItemModelList = JsonUtil.stringToArray(newResult, CheckItemModel[].class);
//                            for (int i = 0; i < checkItemModelList.size(); i++) {
//                                UtilsLog.e("checkItemModelList=11=" + checkItemModelList.get(i).toString());
//                            }

                        } else {
//                            Toast.makeText(instances, getResources().getString(R.string.network_error),
// Toast.LENGTH_LONG).show();
                            UtilsLog.e("getGET_ALL_ITEMList-result==" + "没有数据");
                        }
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
//                        CommonUtils.hideLoadingDialog(instances);
                        UtilsLog.e("getGET_ALL_ITEMList-onError==" + response.body());
                        String logStr = "\n" + "获取所有人工检验项目接口----onError" + "\n" + "result::" + response.body() + "\n";
                        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
//                        Toast.makeText(LoginActivity.this, getResources().getString(R.string.services_error), Toast
//                                .LENGTH_LONG).show();
                    }
                });
    }


    @Override
    protected void onDestroy() {
        super.onDestroy();
        String logStrf = "\n" + "onDestroy-----登陆-------" + "\n";
        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStrf.getBytes());
        OkGo.getInstance().cancelTag(this);
        if (pop2_userlist != null) {
            pop2_userlist.dismiss();
            pop2_userlist = null;
        }
        if (pop2 != null) {
            pop2.dismiss();
            pop2 = null;
        }
        instances = null;
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode) {
            case PermissionChecker.PERMISSION_REQUEST_CODE:
                if (permissionChecker.hasAllPermissionsGranted(grantResults)) {
                    // 执行你的相关操作
//                    if(type == 1){
//                        startAudio();
//                    }else if(type == 2){
//                        startVideo();
//                    }
                } else {
                    // 权限拒绝后的提示
                    permissionChecker.showDialog();
                }
                break;
        }
    }

    private List<UserAccountModel> filterRoleRight(List<UserAccountModel> userList) {
        List<UserAccountModel> resultList0 = new ArrayList<>();
        if (userList != null && userList.size() > 0) {
            for (int i = 0; i < userList.size(); i++) {
                if (userList.get(i).getUserRight().contains("0") ||
                        userList.get(i).getUserRight().contains("3")
                        || userList.get(i).getUserRight().contains("4")
                        || userList.get(i).getUserRight().contains("5")
                        || userList.get(i).getUserRight().contains("6")) {
                    resultList0.add(userList.get(i));
                } else {

                }
            }
        }
//        for (int i = 0; i < resultList0.size(); i++) {
//            UtilsLog.e("过滤后的人员列表==" + i + "===" + resultList0.get(i).toString());
//        }
        return resultList0;
    }

    //退出登录
    private void logOut(String name) {
        String logout_url = "/api/User/" + name + "/UserQuitID";
        UtilsLog.e("退出登录---url=login=" + SharedPreferencesUtils.getIP(instances) + logout_url);
        String logStr = "\n" + "退出登录--login--" + "\n" + "URL::" +
                SharedPreferencesUtils.getIP(instances) + logout_url + "\n";
        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
        OkGo.<String>get(SharedPreferencesUtils.getIP(instances) + logout_url).tag(instances)
                .execute(new StringCallback() {
                    @Override
                    public void onStart(Request<String, ? extends Request> request) {
                        super.onStart(request);
//                        WaitDialog.show(instances, "加载中...");
//                        CommonUtils.showLoadingDialog(instances, "加载中...");
                    }

                    @Override
                    public void onSuccess(Response<String> response) {
//                        CommonUtils.hideLoadingDialog(instances);
                        String result = response.body();
//                        UtilsLog.e("getDataUsersList-result=login=" + result);
//                        String newResult = result.substring(1, result.length() - 1).replaceAll("\\\\", "");
                        UtilsLog.e("退出登录-newResult=login=" + result);
                        WaitDialog.dismiss();
                    }

                    @Override
                    public void onError(Response<String> response) {
                        super.onError(response);
                        WaitDialog.dismiss();
//                        CommonUtils.hideLoadingDialog(instances);
                        String logStr = "\n" + "退出登录-login---onError" + "\n" + "URL::" +
                                SharedPreferencesUtils.getIP(instances) +
                                logout_url + "\n" + "result::" + response.body() + "\n";
                        PDALogUtils.createLogFile(BaseApplication.JIANCE_MODE, logStr.getBytes());
                        UtilsLog.e("退出登录-onError=login=" + response.body());

//                        Toast.makeText(instances, "读取人员列表失败，请退出重试", Toast
//                                .LENGTH_LONG).show();
                    }
                });
    }


    String result_base64 = "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";

    void setImg() {
        String result_1 = Base64Util.base64Decode(result_base64, "UTF-8");
//        Glide.with(instances).load(result_1).into(imageView);
        byte[] decodedString = Base64.decode(result_base64, Base64.DEFAULT);
        Glide.with(instances).load(decodedString)
                .diskCacheStrategy(DiskCacheStrategy.NONE) //跳过磁盘缓存
                .skipMemoryCache(true)//跳过内存缓存
                .into(imageView);

    }
}